using UnityEngine;
using System.IO;
using System.Collections.Generic;
using System.Data;
using OfficeOpenXml; // 引用EPPlus库 (位于Assets/EPPlus-DLL/EPPlus.dll)

/// <summary>
/// Excel文件导入器，负责读取Excel文件并转换为游戏中的单词数据
/// </summary>
public class ExcelFileImporter : MonoBehaviour
{
    // 单例实例
    private static ExcelFileImporter _instance;
    
    // 静态字段，用于存储解析好的单词数据，在场景之间保持
    public static List<Word> ImportedWords = new List<Word>();
    
    // 标记是否有新导入的单词
    public static bool HasNewImportedWords = false;
    
    public static ExcelFileImporter Instance
    {
        get
        {
            if (_instance == null)
            {
                GameObject go = new GameObject("ExcelFileImporter");
                _instance = go.AddComponent<ExcelFileImporter>();
                DontDestroyOnLoad(go);
            }
            return _instance;
        }
    }
    
    private void Awake()
    {
        if (_instance != null && _instance != this)
        {
            Destroy(gameObject);
            return;
        }
        
        _instance = this;
        DontDestroyOnLoad(gameObject);
        
        // 注释：当前EPPlus版本不支持LicenseContext设置
        // 较新版本的EPPlus (4.5+)才需要设置: ExcelPackage.LicenseContext = LicenseContext.NonCommercial
        Debug.Log("ExcelFileImporter已初始化");
        
        // 记录当前EPPlus版本
        try {
            System.Type excelType = typeof(ExcelPackage);
            System.Reflection.AssemblyName assemblyName = excelType.Assembly.GetName();
            Debug.Log($"使用EPPlus版本: {assemblyName.Version}");
        }
        catch (System.Exception ex) {
            Debug.LogWarning($"获取EPPlus版本信息失败: {ex.Message}");
        }
        
        // 自动重新导入上次使用的Excel文件
        StartCoroutine(AutoReloadLastExcelFile());
    }
    
    /// <summary>
    /// 自动重新导入上次使用的Excel文件
    /// </summary>
    private System.Collections.IEnumerator AutoReloadLastExcelFile()
    {
        // 稍微延迟执行，确保所有组件都已初始化
        yield return new UnityEngine.WaitForSeconds(0.5f);
        
        // 检查是否有持久化的导入数据
        if (ImportedWords.Count > 0)
        {
            Debug.Log("已有导入的单词数据在内存中，无需重新导入");
            // 确保标记为有新导入数据
            HasNewImportedWords = true;
            yield break;
        }
        
        // 检查Android导入状态
        bool hasAndroidImport = HasAndroidImport();
        if (hasAndroidImport)
        {
            Debug.Log("检测到有Android导入状态，但无法自动重新导入文件数据");
            Debug.LogWarning("Android导入的数据无法自动重新加载，请用户重新选择文件导入");
            
            // 这里可以添加提示用户重新导入的UI逻辑
            
            // 清除Android导入标志
            ClearAndroidImportFlag();
            yield break;
        }
        
        // 尝试加载上次导入的文件
        string lastFilePath = GetLastImportedFilePath();
        
        if (!string.IsNullOrEmpty(lastFilePath) && System.IO.File.Exists(lastFilePath))
        {
            Debug.Log($"尝试自动重新导入上次的Excel文件: {lastFilePath}");
            
            // 在导入前确保之前的数据已清空
            parsedWords.Clear();
            
            bool success = ImportExcelFile(lastFilePath);
            
            if (success)
            {
                Debug.Log($"成功自动重新导入Excel文件: {lastFilePath}");
                
                // 确保WordDatabase能获取到新导入的单词
                HasNewImportedWords = true;
                
                // 如果WordDatabase已经初始化，直接通知更新
                if (WordDatabase.Instance != null)
                {
                    WordDatabase.Instance.CheckForImportedWords();
                }
            }
            else
            {
                Debug.LogError($"自动重新导入Excel文件失败: {lastFilePath}");
                
                // 如果导入失败，清除保存的路径，避免下次启动时继续尝试导入失败的文件
                PlayerPrefs.DeleteKey("LastExcelFilePath");
                PlayerPrefs.Save();
            }
        }
        else if (!string.IsNullOrEmpty(lastFilePath))
        {
            Debug.LogWarning($"上次的Excel文件不存在或已移动: {lastFilePath}");
            
            // 清除无效的路径
            PlayerPrefs.DeleteKey("LastExcelFilePath");
            PlayerPrefs.Save();
        }
    }

    // 临时存储解析的单词
    private List<Word> parsedWords = new List<Word>();
    
    /// <summary>
    /// 导入Excel文件
    /// </summary>
    /// <param name="filePath">Excel文件路径</param>
    /// <returns>是否导入成功</returns>
    public bool ImportExcelFile(string filePath)
    {
        // 检查文件是否存在
        if (!File.Exists(filePath))
        {
            Debug.LogError($"文件不存在: {filePath}");
            return false;
        }
        
        // 检查文件扩展名
        string extension = Path.GetExtension(filePath).ToLower();
        if (extension != ".xlsx" && extension != ".xls")
        {
            Debug.LogError($"不支持的文件类型: {extension}，请使用 .xlsx 或 .xls 格式");
            return false;
        }
        
        Debug.Log($"开始导入Excel文件: {filePath}");
        
        // 清空之前解析的单词
        parsedWords.Clear();
        
        try
        {
            // 使用EPPlus库读取Excel文件
            FileInfo fileInfo = new FileInfo(filePath);
            using (var package = new ExcelPackage(fileInfo))
            {
                // 检查工作表
                int worksheetCount = package.Workbook.Worksheets.Count;
                Debug.Log($"Excel文件包含 {worksheetCount} 个工作表");
                
                if (worksheetCount == 0)
                {
                    Debug.LogError("Excel文件不包含任何工作表");
                    return false;
                }
                
                // 尝试所有可能的工作表索引
                bool foundValidWorksheet = false;
                ExcelWorksheet worksheet = null;
                
                // EPPlus可能使用0-based或1-based索引，这里我们尝试所有可能
                for (int i = 0; i < worksheetCount + 1; i++)
                {
                    try
                    {
                        worksheet = package.Workbook.Worksheets[i];
                        if (worksheet != null && worksheet.Dimension != null)
                        {
                            foundValidWorksheet = true;
                            Debug.Log($"找到有效工作表，索引 {i}, 名称: {worksheet.Name}");
                            break;
                        }
                    }
                    catch (System.Exception ex)
                    {
                        Debug.LogWarning($"尝试访问工作表 {i} 时出错: {ex.Message}");
                        continue;
                    }
                }
                
                // 如果尝试所有索引都失败，尝试按名称获取第一个工作表
                if (!foundValidWorksheet && worksheetCount > 0)
                {
                    try
                    {
                        worksheet = package.Workbook.Worksheets["Sheet1"];
                        if (worksheet != null && worksheet.Dimension != null)
                        {
                            foundValidWorksheet = true;
                            Debug.Log($"通过名称找到有效工作表: Sheet1");
                        }
                    }
                    catch (System.Exception ex)
                    {
                        Debug.LogWarning($"尝试按名称访问工作表时出错: {ex.Message}");
                    }
                }
                
                if (!foundValidWorksheet || worksheet == null)
                {
                    Debug.LogError("无法找到有效的工作表，请确保Excel文件格式正确并包含数据");
                    return false;
                }
                
                // 解析工作表
                ParseExcelWorksheet(worksheet);
            }

            // 将解析的单词添加到WordDatabase
            if (parsedWords.Count > 0)
            {
                UpdateWordDatabase();
                Debug.Log($"成功导入 {parsedWords.Count} 个单词");
                
                // 将文件路径保存到PlayerPrefs，以便下次启动时自动加载
                PlayerPrefs.SetString("LastExcelFilePath", filePath);
                PlayerPrefs.Save();
                
                return true;
            }
            else
            {
                Debug.LogWarning("没有从Excel文件中解析到有效单词，请检查文件格式是否正确");
                return false;
            }
        }
        catch (System.Exception e)
        {
            Debug.LogError($"导入Excel文件时出错: {e.Message}\n详细信息: {e.StackTrace}");
            return false;
        }
    }
    
    /// <summary>
    /// 解析Excel工作表
    /// </summary>
    private void ParseExcelWorksheet(ExcelWorksheet worksheet)
    {
        try
        {
            if (worksheet == null || worksheet.Dimension == null)
            {
                Debug.LogError("工作表为空或没有数据范围");
                return;
            }
            
            int rowCount = worksheet.Dimension.Rows;
            int colCount = worksheet.Dimension.Columns;
            
            Debug.Log($"工作表大小: {rowCount}行 x {colCount}列");
            
            if (rowCount <= 1 || colCount < 3)
            {
                Debug.LogWarning($"工作表数据不足: 行数={rowCount}, 列数={colCount}, 需要至少2行和3列");
                return;
            }
            
            // 以3列为一组处理：英文、音标、中文
            for (int colGroup = 0; colGroup + 2 < colCount; colGroup += 3)
            {
                int englishCol = colGroup + 1; // EPPlus是1-based索引
                int phoneticCol = colGroup + 2;
                int chineseCol = colGroup + 3;
                
                Debug.Log($"处理列组: 英文={englishCol}, 音标={phoneticCol}, 中文={chineseCol}");
                
                int currentRow = 1; // EPPlus从1开始计数
                int wordsInGroup = 0;
                
                // 处理所有行，直到表格结束
                while (currentRow <= rowCount)
                {
                    try
                    {
                        // 检测连续的非空英文单元格
                        List<string> englishParts = new List<string>();
                        string fullEnglish = "";
                        int startRow = currentRow;
                        
                        // 收集连续的非空英文部分
                        while (currentRow <= rowCount && 
                               !string.IsNullOrEmpty(GetCellValue(worksheet, currentRow, englishCol)))
                        {
                            string part = GetCellValue(worksheet, currentRow, englishCol);
                            englishParts.Add(part);
                            fullEnglish += part;
                            currentRow++;
                        }
                        
                        // 如果没有找到英文部分，跳到下一行继续搜索
                        if (englishParts.Count == 0)
                        {
                            currentRow++;
                            continue;
                        }
                        
                        // 收集音标部分
                        List<string> phoneticParts = new List<string>();
                        string fullPhonetic = "";
                        int phoneticRow = startRow;
                        
                        while (phoneticRow < currentRow)
                        {
                            string part = GetCellValue(worksheet, phoneticRow, phoneticCol);
                            phoneticParts.Add(string.IsNullOrEmpty(part) ? "" : part);
                            fullPhonetic += (string.IsNullOrEmpty(part) ? "" : part + " "); // 添加空格分隔
                            phoneticRow++;
                        }
                        
                        // 去除最后一个多余的空格
                        if (fullPhonetic.Length > 0)
                        {
                            fullPhonetic = fullPhonetic.TrimEnd();
                        }
                        
                        // 确保音标分段数量与单词分段一致
                        if (phoneticParts.Count != englishParts.Count)
                        {
                            Debug.LogWarning($"单词 '{fullEnglish}' 的音标分段数量({phoneticParts.Count})与单词分段数量({englishParts.Count})不匹配，尝试智能分配...");
                            
                            // 可能需要补充或合并音标段
                            if (phoneticParts.Count < englishParts.Count)
                            {
                                // 音标段数不足，补充空字符串
                                while (phoneticParts.Count < englishParts.Count)
                                {
                                    phoneticParts.Add("");
                                }
                            }
                            else if (phoneticParts.Count > englishParts.Count)
                            {
                                // 音标段数过多，合并多余的段
                                List<string> adjustedPhoneticParts = new List<string>();
                                for (int i = 0; i < englishParts.Count - 1; i++)
                                {
                                    adjustedPhoneticParts.Add(phoneticParts[i]);
                                }
                                
                                // 合并剩余的所有音标段到最后一个
                                string lastPart = "";
                                for (int i = englishParts.Count - 1; i < phoneticParts.Count; i++)
                                {
                                    lastPart += phoneticParts[i] + " ";
                                }
                                adjustedPhoneticParts.Add(lastPart.TrimEnd());
                                
                                phoneticParts = adjustedPhoneticParts;
                            }
                        }
                        
                        // 获取中文意思（通常在第一行）
                        string chinese = GetCellValue(worksheet, startRow, chineseCol);
                        
                        // 创建单词结构体并添加到列表
                        Word word = new Word
                        {
                            english = fullEnglish,
                            phonetic = fullPhonetic,
                            chinese = chinese,
                            parts = englishParts,
                            phoneticParts = phoneticParts,
                            incomplete = "", // 稍后生成
                            answer = ""      // 稍后生成
                        };
                        
                        parsedWords.Add(word);
                        wordsInGroup++;
                        
                        Debug.Log($"解析单词: {fullEnglish}, 音标: {fullPhonetic}, 中文: {chinese}, 英文拆分: {string.Join(",", englishParts)}, 音标拆分: {string.Join(",", phoneticParts)}");
                        
                        // 跳过空行（如果有）
                        if (currentRow <= rowCount && 
                            string.IsNullOrEmpty(GetCellValue(worksheet, currentRow, englishCol)))
                        {
                            currentRow++;
                        }
                    }
                    catch (System.Exception ex)
                    {
                        Debug.LogError($"解析第 {currentRow} 行时出错: {ex.Message}");
                        // 跳过出错的行，继续解析下一行
                        currentRow++;
                    }
                }
                
                Debug.Log($"列组 {colGroup/3 + 1} 共解析了 {wordsInGroup} 个单词");
            }
        }
        catch (System.Exception ex)
        {
            Debug.LogError($"解析工作表时出错: {ex.Message}\n{ex.StackTrace}");
        }
    }
    
    /// <summary>
    /// 安全地获取单元格的值
    /// </summary>
    private string GetCellValue(ExcelWorksheet worksheet, int row, int col)
    {
        if (worksheet == null)
        {
            Debug.LogError("工作表为空，无法获取单元格值");
            return "";
        }
        
        if (row <= 0 || col <= 0)
        {
            Debug.LogError($"单元格坐标无效: [{row},{col}]，EPPlus索引从1开始");
            return "";
        }
        
        try
        {
            var cell = worksheet.Cells[row, col];
            if (cell != null && cell.Value != null)
            {
                return cell.Value.ToString().Trim();
            }
        }
        catch (System.IndexOutOfRangeException)
        {
            Debug.LogWarning($"单元格坐标超出范围: [{row},{col}]");
        }
        catch (System.Exception e)
        {
            Debug.LogError($"获取单元格值时出错: [{row},{col}] - {e.Message}");
        }
        
        return "";
    }
    
    /// <summary>
    /// 更新WordDatabase中的单词列表，或存储到静态字段等待Battle场景加载
    /// </summary>
    private void UpdateWordDatabase()
    {
        // 尝试获取WordDatabase实例
        WordDatabase wordDB = WordDatabase.Instance;
        
        if (wordDB != null)
        {
            // 如果WordDatabase实例存在，直接更新单词列表
            wordDB.SetWordList(parsedWords);
            Debug.Log($"单词列表已直接更新到WordDatabase，共 {parsedWords.Count} 个单词");
        }
        else
        {
            // 如果WordDatabase实例不存在（可能在Login场景），存储到静态字段
            ImportedWords.Clear();
            ImportedWords.AddRange(parsedWords);
            HasNewImportedWords = true;
            Debug.Log($"单词列表已存储在静态字段中，等待Battle场景加载时应用，共 {parsedWords.Count} 个单词");
        }
    }
    
    /// <summary>
    /// 导入Android平台的Excel文件
    /// </summary>
    /// <param name="fileData">文件二进制数据</param>
    /// <returns>是否导入成功</returns>
    public bool ImportExcelFromAndroid(byte[] fileData)
    {
        if (fileData == null || fileData.Length == 0)
        {
            Debug.LogError("文件数据为空");
            return false;
        }
        
        Debug.Log($"开始从Android导入Excel文件，大小: {fileData.Length} 字节");
        
        // 清空之前解析的单词
        parsedWords.Clear();
        
        try
        {
            // 从内存字节数组创建流
            using (var stream = new MemoryStream(fileData))
            {
                // 使用EPPlus库读取Excel数据
                using (var package = new ExcelPackage(stream))
                {
                    // 检查工作表
                    int worksheetCount = package.Workbook.Worksheets.Count;
                    Debug.Log($"Excel文件包含 {worksheetCount} 个工作表");
                    
                    if (worksheetCount == 0)
                    {
                        Debug.LogError("Excel文件不包含任何工作表");
                        return false;
                    }
                    
                    // 尝试所有可能的工作表索引
                    bool foundValidWorksheet = false;
                    ExcelWorksheet worksheet = null;
                    
                    // EPPlus可能使用0-based或1-based索引，这里我们尝试所有可能
                    for (int i = 0; i < worksheetCount + 1; i++)
                    {
                        try
                        {
                            worksheet = package.Workbook.Worksheets[i];
                            if (worksheet != null && worksheet.Dimension != null)
                            {
                                foundValidWorksheet = true;
                                Debug.Log($"找到有效工作表，索引 {i}, 名称: {worksheet.Name}");
                                break;
                            }
                        }
                        catch (System.Exception ex)
                        {
                            Debug.LogWarning($"尝试访问工作表 {i} 时出错: {ex.Message}");
                            continue;
                        }
                    }
                    
                    // 如果尝试所有索引都失败，尝试按名称获取第一个工作表
                    if (!foundValidWorksheet && worksheetCount > 0)
                    {
                        try
                        {
                            worksheet = package.Workbook.Worksheets["Sheet1"];
                            if (worksheet != null && worksheet.Dimension != null)
                            {
                                foundValidWorksheet = true;
                                Debug.Log($"通过名称找到有效工作表: Sheet1");
                            }
                        }
                        catch (System.Exception ex)
                        {
                            Debug.LogWarning($"尝试按名称访问工作表时出错: {ex.Message}");
                        }
                    }
                    
                    if (!foundValidWorksheet || worksheet == null)
                    {
                        Debug.LogError("无法找到有效的工作表，请确保Excel文件格式正确并包含数据");
                        return false;
                    }
                    
                    // 解析工作表
                    ParseExcelWorksheet(worksheet);
                }
            }

            // 将解析的单词添加到WordDatabase
            if (parsedWords.Count > 0)
            {
                UpdateWordDatabase();
                Debug.Log($"成功从Android导入 {parsedWords.Count} 个单词");
                
                // 为Android导入设置状态标记
                PlayerPrefs.SetInt("HasAndroidImport", 1);
                PlayerPrefs.Save();
                
                return true;
            }
            else
            {
                Debug.LogWarning("没有从Excel文件中解析到有效单词，请检查文件格式是否正确");
                return false;
            }
        }
        catch (System.Exception e)
        {
            Debug.LogError($"从Android导入Excel文件时出错: {e.Message}\n详细信息: {e.StackTrace}");
            return false;
        }
    }
    
    /// <summary>
    /// 检查是否有Android导入的数据
    /// </summary>
    public bool HasAndroidImport()
    {
        return PlayerPrefs.GetInt("HasAndroidImport", 0) == 1;
    }
    
    /// <summary>
    /// 清除Android导入标记
    /// </summary>
    public void ClearAndroidImportFlag()
    {
        PlayerPrefs.SetInt("HasAndroidImport", 0);
        PlayerPrefs.Save();
    }
    
    /// <summary>
    /// 获取上次导入的Excel文件路径
    /// </summary>
    public string GetLastImportedFilePath()
    {
        return PlayerPrefs.GetString("LastExcelFilePath", "");
    }

    /// <summary>
    /// 清理导入的单词数据
    /// </summary>
    public static void ClearImportedWords()
    {
        ImportedWords.Clear();
        HasNewImportedWords = false;
        Debug.Log("已清理导入的单词数据");
    }
} 